A Teacher in the Living Room? Educational Media for Babies, Toddlers, and Preschoolers

Examines available research, and arguments by proponents and critics, of electronic educational media use by young children. Examines educational claims in marketing and provides recommendations for developing research and product standards

SOCIOECONOMIC DETERMINANTS OF FOOD EXPENDITURE PATTERNS AMONG RACIALLY DIFFERENT LOW-INCOME HOUSEHOLDS: AN EMPIRICAL ANALYSIS

This paper examines the impact of selected socioeconomic characteristics on aggregate and group food expenditure patterns of racially different low-income households. A double logarithmic functional form was used to explain responses in household food expenditures to socioeconomic factors. Household income, family size, and Food Stamp Program participation were found to exert a strong positive impact on food expenditures. The general educational level of the homemaker registered no significant impact on household food expenditures. However, the nutritional knowledge of the homemaker increased the efficiency of food purchasing activities.Food Consumption/Nutrition/Food Safety,

Spreading in Social Systems: Reflections

In this final chapter, we consider the state-of-the-art for spreading in social systems and discuss the future of the field. As part of this reflection, we identify a set of key challenges ahead. The challenges include the following questions: how can we improve the quality, quantity, extent, and accessibility of datasets? How can we extract more information from limited datasets? How can we take individual cognition and decision making processes into account? How can we incorporate other complexity of the real contagion processes? Finally, how can we translate research into positive real-world impact? In the following, we provide more context for each of these open questions.Comment: 7 pages, chapter to appear in "Spreading Dynamics in Social Systems"; Eds. Sune Lehmann and Yong-Yeol Ahn, Springer Natur

An Experimental Evaluation of Deliberate Unsoundness in a Static Program Analyzer

Abstract. Many practical static analyzers are not completely sound by design. Their designers trade soundness in order to increase automa-tion, improve performance, and reduce the number of false positives or the annotation overhead. However, the impact of such design decisions on the effectiveness of an analyzer is not well understood. In this pa-per, we report on the first systematic effort to document and evaluate the sources of unsoundness in a static analyzer. We present a code in-strumentation that reflects the sources of deliberate unsoundness in the.NET static analyzer Clousot. We have instrumented code from several open source projects to evaluate how often concrete executions violate Clousot’s unsound assumptions. In our experiments, this was the case in 8–29 % of all analyzed methods. Our approach and findings can guide users of static analyzers in using them fruitfully, and designers in finding good trade-offs.

Automatic Verification of Erlang-Style Concurrency

This paper presents an approach to verify safety properties of Erlang-style, higher-order concurrent programs automatically. Inspired by Core Erlang, we introduce Lambda-Actor, a prototypical functional language with pattern-matching algebraic data types, augmented with process creation and asynchronous message-passing primitives. We formalise an abstract model of Lambda-Actor programs called Actor Communicating System (ACS) which has a natural interpretation as a vector addition system, for which some verification problems are decidable. We give a parametric abstract interpretation framework for Lambda-Actor and use it to build a polytime computable, flow-based, abstract semantics of Lambda-Actor programs, which we then use to bootstrap the ACS construction, thus deriving a more accurate abstract model of the input program. We have constructed Soter, a tool implementation of the verification method, thereby obtaining the first fully-automatic, infinite-state model checker for a core fragment of Erlang. We find that in practice our abstraction technique is accurate enough to verify an interesting range of safety properties. Though the ACS coverability problem is Expspace-complete, Soter can analyse these verification problems surprisingly efficiently.Comment: 12 pages plus appendix, 4 figures, 1 table. The tool is available at http://mjolnir.cs.ox.ac.uk/soter

Guiding Dynamic Symbolic Execution Toward Unverified Program Executions

Most techniques to detect program errors, such as testing, code reviews, and static program analysis, do not fully verify all possible executions of a program. They leave executions unverified when they do not check certain properties, fail to verify properties, or check properties under certain unsound assumptions such as the absence of arithmetic overflow. In this paper, we present a technique to complement partial verification results by automatic test case generation. In contrast to existing work, our technique supports the common case that the verification results are based on unsound assumptions. We annotate programs to reflect which executions have been verified, and under which assumptions. These annotations are then used to guide dynamic symbolic execution toward unverified program executions. Our main technical contribution is a code instrumentation that causes dynamic symbolic execution to abort tests that lead to verified executions, to prune parts of the search space, and to prioritize tests that cover more properties that are not fully verified. We have implemented our technique for the .NET static analyzer Clousot and the dynamic symbolic execution tool Pex. It produces smaller test suites (by up to 19.2%), covers more unverified executions (by up to 7.1%), and reduces testing time (by up to 52.4%) compared to combining Clousot and Pex without our technique

Static Trace-Based Deadlock Analysis for Synchronous Mini-Go

We consider the problem of static deadlock detection for programs in the Go programming language which make use of synchronous channel communications. In our analysis, regular expressions extended with a fork operator capture the communication behavior of a program. Starting from a simple criterion that characterizes traces of deadlock-free programs, we develop automata-based methods to check for deadlock-freedom. The approach is implemented and evaluated with a series of examples